// import ReactNativeBlobUtil from 'react-native-blob-util';

// const {fs: RNFS} = ReactNativeBlobUtil;

// // 支持的图片格式
// const SUPPORTED_FORMATS = ['png', 'jpg', 'jpeg', 'gif', 'webp'] as const;
// type ImageFormat = (typeof SUPPORTED_FORMATS)[number];

// class ImageCacheManager {
//   private cacheDir: string;
//   private readonly maxCacheSize: number = 200 * 1024 * 1024; // 100MB 默认缓存上限

//   constructor() {
//     this.cacheDir = `${RNFS.dirs.CacheDir}/image-cache`;
//     this.initCacheDir();
//   }

//   private async initCacheDir() {
//     const exists = await RNFS.exists(this.cacheDir);
//     if (!exists) {
//       await RNFS.mkdir(this.cacheDir);
//     }
//   }

//   // 获取图片格式
//   private getImageFormat(url: string): ImageFormat {
//     const extension = url.split('.').pop()?.toLowerCase() || '';
//     return SUPPORTED_FORMATS.includes(extension as ImageFormat)
//       ? (extension as ImageFormat)
//       : 'jpg';
//   }

//   // 生成哈希文件名
//   private generateHash(str: string): string {
//     let hash = 0;
//     for (let i = 0; i < str.length; i++) {
//       const char = str.charCodeAt(i);
//       hash = (hash << 5) - hash + char;
//       hash = hash & hash;
//     }
//     return Math.abs(hash).toString(16);
//   }

//   // 获取缓存文件路径
//   private getCacheFilePath(url: string): string {
//     const fileName = this.generateHash(url);
//     const format = this.getImageFormat(url);
//     return `${this.cacheDir}/${fileName}.${format}`;
//   }

//   // 检查图片是否已缓存
//   private async isImageCached(url: string): Promise<boolean> {
//     const filePath = this.getCacheFilePath(url);
//     return await RNFS.exists(filePath);
//   }

//   // 获取缓存大小
//   private async getCacheSize(): Promise<number> {
//     try {
//       const files = await RNFS.ls(this.cacheDir);
//       const sizes = await Promise.all(
//         files.map(file => RNFS.stat(this.cacheDir + '/' + file)),
//       );
//       return sizes.reduce((total, stat) => total + (stat.size || 0), 0);
//     } catch (error) {
//       console.error('Failed to get cache size:', error);
//       return 0;
//     }
//   }

//   // 清理旧缓存
//   private async cleanOldCache(): Promise<void> {
//     try {
//       const files = await RNFS.ls(this.cacheDir);
//       const stats = await Promise.all(
//         files.map(async file => ({
//           path: file.path,
//           stat: await RNFS.stat(file.path),
//         })),
//       );

//       // 按最后访问时间排序
//       stats.sort((a, b) => (a.stat.mtime || 0) - (b.stat.mtime || 0));

//       // 删除最旧的文件直到缓存大小小于限制
//       let currentSize = stats.reduce(
//         (size, file) => size + (file.stat.size || 0),
//         0,
//       );
//       for (const file of stats) {
//         if (currentSize <= this.maxCacheSize) break;
//         await RNFS.unlink(file.path);
//         currentSize -= file.stat.size || 0;
//       }
//     } catch (error) {
//       console.error('Failed to clean old cache:', error);
//     }
//   }

//   // 下载图片到缓存
//   private async downloadImage(url: string, filePath: string): Promise<string> {
//     try {
//       const response = await RNFS.downloadFile({
//         fromUrl: url,
//         toFile: filePath,
//         background: true,
//         discretionary: true,
//         progress: res => {
//           const progress = (res.bytesWritten / res.contentLength) * 100;
//           console.log(`Image download progress: ${progress}%`);
//         },
//       }).promise;

//       if (response.statusCode === 200) {
//         // 检查并清理旧缓存
//         const cacheSize = await this.getCacheSize();
//         if (cacheSize > this.maxCacheSize) {
//           await this.cleanOldCache();
//         }
//         return filePath;
//       }
//       throw new Error('Download failed');
//     } catch (error) {
//       console.error('Error downloading image:', error);
//       throw error;
//     }
//   }

//   // 获取图片 URI（主要方法）
//   async getImageUri(url: string): Promise<string> {
//     // 进行URL编码，避免空格等特殊字符影响缓存路径
//     const encodedUrl = encodeURI(url);

//     try {
//       const filePath = this.getCacheFilePath(encodedUrl);
//       const isCached = await this.isImageCached(encodedUrl);

//       if (isCached) {
//         console.log('Using cached image');
//         return `file://${filePath}`;
//       }
//       // // 如果是包内资源，则跳过，返回原始URL
//       // if (filePath.startsWith('/') || url.startsWith('bundle://')) {
//       //   return url;
//       // }

//       console.log('Downloading image...');
//       await this.downloadImage(encodedUrl, filePath);
//       return `file://${filePath}`;
//     } catch (error) {
//       console.error('Failed to get image URI:', error);
//       return encodedUrl;
//     }
//   }

//   // 预加载图片
//   async preloadImages(urls: string[]): Promise<void> {
//     const uniqueUrls = [...new Set(urls)];
//     await Promise.all(uniqueUrls.map(url => this.getImageUri(url)));
//   }

//   // 检查图片是否已缓存（供外部使用）
//   async hasCache(url: string): Promise<boolean> {
//     return this.isImageCached(url);
//   }

//   // 清理所有缓存
//   async clearCache(): Promise<void> {
//     try {
//       const files = await RNFS.readDir(this.cacheDir);
//       await Promise.all(files.map(file => RNFS.unlink(file.path)));
//       console.log('Image cache cleared successfully');
//     } catch (error) {
//       console.error('Error clearing image cache:', error);
//       throw error;
//     }
//   }

//   // 获取缓存统计信息
//   async getCacheStats(): Promise<{size: number; count: number}> {
//     try {
//       const files = await RNFS.readDir(this.cacheDir);
//       const size = await this.getCacheSize();
//       return {
//         size,
//         count: files.length,
//       };
//     } catch (error) {
//       console.error('Failed to get cache stats:', error);
//       return {size: 0, count: 0};
//     }
//   }
// }

// // 导出单例
// export const imageCache = new ImageCacheManager();
